<!DOCTYPE html>
<html lang="zh">

<head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>
    
    结构体类型 - DSRBLOG
    
  </title>
  

  
  
  <link href="atom.xml" rel="alternate" title="DSRBLOG" type="application/atom+xml">
  <link rel="stylesheet" href="asset/css/style.min.css">
  <link rel="stylesheet" href="asset/css/doc.css">
  <script src="asset/app.js"></script>


</head>

<body> <section class="ct-body">
	<div class="container">
		<div class="columns is-variable bd-klmn-columns is-4 is-centered">
			<div class="column is-four-fifths">
				<div class="post-body single-content">
					
					<h1 class="title">
						结构体类型
					</h1>


					<div class="media">
						
						
						<div class="media-content">
							<div class="content">
								<p>
									<span class="date">2022/01/28 01:51 上午</span>
									

									

									<br />
									<span class="tran-tags">Tags:</span>&nbsp;
									
									<a class="tag is-link is-light">#C语言</a>
									

								</p>
							</div>
						</div>

					</div>
				</div>
				<article class="markdown-body single-content">
					<h2><a id="%E7%BB%93%E6%9E%84%E4%BD%93%E7%B1%BB%E5%9E%8B%E7%9A%84%E5%AE%9A%E4%B9%89%E6%96%B9%E6%B3%95" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>结构体类型的定义方法</h2>
<h3><a id="%E5%A3%B0%E6%98%8E%E4%B8%80%E4%B8%AA%E7%BB%93%E6%9E%84%E4%BD%93%E7%B1%BB%E5%9E%8B%E7%9A%84%E4%B8%80%E8%88%AC%E5%BD%A2%E5%BC%8F" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>声明一个结构体类型的一般形式</h3>
<pre class="line-numbers"><code class="language-c">struct 结构体名
{成员表列};
</code></pre>
<ul>
<li>
<p>结构体类型的名字是由一个关键字<code>struct</code>和结构体名二者结合而成（例如<code>struct student</code>）</p>
</li>
<li>
<p>定义的结构只能在初始化时对整体进行赋值，否则只能分别对结构内的每个成员单独赋值</p>
</li>
</ul>
<h4><a id="%E4%BE%8B" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>例</h4>
<pre class="line-numbers"><code class="language-c">struct student
{
    int num;       //学号为整型
    char name[20]; //姓名为字符串
    char sex;      //性别为字符型
    int age;       //年龄为整型
    float score;   //成绩为实型
    char addr[30]; //地址为字符穿
};
</code></pre>
<h2><a id="%E7%BB%93%E6%9E%84%E4%BD%93%E7%B1%BB%E5%9E%8B%E5%8F%98%E9%87%8F%E7%9A%84%E5%AE%9A%E4%B9%89%E4%B8%8E%E5%88%9D%E5%A7%8B%E5%8C%96" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>结构体类型变量的定义与初始化</h2>
<h3><a id="%E5%8F%AF%E4%BB%A5%E9%87%87%E7%94%A8%E4%BB%A5%E4%B8%8B3%E7%A7%8D%E6%96%B9%E6%B3%95%E5%AE%9A%E4%B9%89%E7%BB%93%E6%9E%84%E4%BD%93%E7%B1%BB%E5%9E%8B%E5%8F%98%E9%87%8F" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>可以采用以下3种方法定义结构体类型变量</h3>
<h4><a id="%E4%B8%80%E3%80%81%E5%85%88%E5%A3%B0%E6%98%8E%E7%BB%93%E6%9E%84%E4%BD%93%E7%B1%BB%E5%9E%8B%EF%BC%8C%E5%86%8D%E5%AE%9A%E4%B9%89%E8%AF%A5%E7%B1%BB%E5%9E%8B%E7%9A%84%E5%8F%98%E9%87%8F%E5%90%8D" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>一、先声明结构体类型，再定义该类型的变量名</h4>
<p>例如：</p>
<pre class="line-numbers"><code class="language-c">struct student student1, student2;
</code></pre>
<h4><a id="%E4%BA%8C%E3%80%81%E5%9C%A8%E5%A3%B0%E6%98%8E%E7%B1%BB%E5%9E%8B%E7%9A%84%E5%90%8C%E6%97%B6%E5%AE%9A%E4%B9%89%E5%8F%98%E9%87%8F" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>二、在声明类型的同时定义变量</h4>
<p>这种形式的定义的一般形式为：</p>
<pre class="line-numbers"><code class="language-c">struct 结构体名
{
    成员表列
}变量名表列;
</code></pre>
<p>例如：</p>
<pre class="line-numbers"><code class="language-c">struct student
{
    成员表列
}student1, student2;
</code></pre>
<h4><a id="%E4%B8%89%E3%80%81%E4%B8%8D%E6%8C%87%E5%AE%9A%E7%B1%BB%E5%9E%8B%E5%90%8D%E8%80%8C%E7%9B%B4%E6%8E%A5%E5%AE%9A%E4%B9%89%E7%BB%93%E6%9E%84%E4%BD%93%E7%B1%BB%E5%9E%8B%E5%8F%98%E9%87%8F%EF%BC%8C%E5%8D%B3%E4%B8%8D%E5%87%BA%E7%8E%B0%E7%BB%93%E6%9E%84%E4%BD%93%E5%90%8D" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>三、不指定类型名而直接定义结构体类型变量，即不出现结构体名</h4>
<p>其一般形式为：</p>
<pre class="line-numbers"><code class="language-c">struct
{
    成员表列
}变量名表列;
</code></pre>
<p><strong>注意：</strong> 因为该结构没有名字，所以通过该方法定义的结构无法再定义其它变量</p>
<h3><a id="%E4%BE%8B%E5%A6%82" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>例如</h3>
<p>把一个学生的信息放在一个结构体变量中，然后输出这个学生的信息</p>
<pre class="line-numbers"><code class="language-c">#include &lt;stdio.h&gt;

int main()
{
    struct stu
    {
        long num;     //学号为整型
        char name[20]; //姓名为字符串
        char sex;      //性别为字符型
        char addr[30]; //地址为字符穿
    };
    struct stu s1 = {191118103213, &quot;贰壹叁&quot;, 'M', &quot;广东省惠州市惠城区&quot;}; //定义结构时对结构整体进行初始化
    printf(&quot;No.%ld\nName:%s\nSex:%c\nAddress:%s&quot;, s1.num, s1.name, s1.sex, s1.addr);
    return 0;
}
</code></pre>
<ul>
<li>输出结构体内容时需要逐个输出结构体内的成员</li>
</ul>
<h2><a id="%E7%BB%93%E6%9E%84%E4%BD%93%E7%B1%BB%E5%9E%8B%E5%8F%98%E9%87%8F%E7%9A%84%E5%BC%95%E7%94%A8" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>结构体类型变量的引用</h2>
<h3><a id="%E5%8F%AF%E4%BB%A5%E5%BC%95%E7%94%A8%E7%BB%93%E6%9E%84%E4%BD%93%E5%8F%98%E9%87%8F%E4%B8%AD%E6%88%90%E5%91%98%E7%9A%84%E5%80%BC" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>可以引用结构体变量中成员的值</h3>
<h4><a id="%E5%BC%95%E7%94%A8%E6%96%B9%E6%B3%95" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>引用方法</h4>
<pre class="line-numbers"><code class="language-c">结构体变量名.成员名
</code></pre>
<h5><a id="%E4%BE%8B%E5%A6%82%EF%BC%9A" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>例如：</h5>
<pre class="line-numbers"><code class="language-c">s1.num
</code></pre>
<p>表示引用<code>s1</code>变量中的<code>num</code>成员，即<code>s1</code>的<code>num</code>项</p>
<ul>
<li>可以对变量的成员赋值，例如<code>s1.num = 10010</code></li>
<li><code>.</code>称为<code>结构成员引用运算符</code>，具有最高的运算优先级</li>
</ul>
<h3><a id="%E5%A4%9A%E6%AC%A1%E4%BD%BF%E7%94%A8%E7%BB%93%E6%9E%84%E6%88%90%E5%91%98%E5%BC%95%E7%94%A8%E8%BF%90%E7%AE%97%E7%AC%A6" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>多次使用结构成员引用运算符</h3>
<p>如果成员本身又属于一个结构体类型，则要用若干个成员运算符，一级一级地找到最低级的成员，并且只能对最低级的成员进行赋值、存取及运算</p>
<h4><a id="%E4%BE%8B%E5%A6%82%EF%BC%9A" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>例如：</h4>
<pre class="line-numbers"><code class="language-c">s1.birthday.month
</code></pre>
<h3><a id="%E7%BB%93%E6%9E%84%E6%88%90%E5%91%98%E7%9A%84%E8%BF%90%E7%AE%97" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>结构成员的运算</h3>
<p>对结构体变量的成员可以像普通变量一样进行各种运算（根据其类型决定可以进行的运算）</p>
<h4><a id="%E4%BE%8B%E5%A6%82%EF%BC%9A" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>例如：</h4>
<pre class="line-numbers"><code class="language-c"> student2.score = student1.score;
 sum = student.score + student2.score;
 studet1.age++;
 ++student2.age;
</code></pre>
<h3><a id="%E5%90%8C%E7%B1%BB%E5%9E%8B%E7%9A%84%E7%BB%93%E6%9E%84%E4%BD%93%E5%8F%98%E9%87%8F%E4%BA%92%E7%9B%B8%E8%B5%8B%E5%80%BC" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>同类型的结构体变量互相赋值</h3>
<h4><a id="%E4%BE%8B%E5%A6%82%EF%BC%9A" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>例如：</h4>
<pre class="line-numbers"><code class="language-c">struct stu {
    成员表列
}student1, student2;

student1 = student2;
</code></pre>
<ul>
<li>字符串类型的结构体变量成员需要通过字符串处理函数<code>strcpy()</code>进行赋值</li>
<li>不能将一个结构体变量做为一个整体进行输入和输出</li>
</ul>
<h3><a id="%E5%BC%95%E7%94%A8%E7%BB%93%E6%9E%84%E4%BD%93%E5%8F%98%E9%87%8F%E6%88%96%E7%BB%93%E6%9E%84%E4%BD%93%E5%8F%98%E9%87%8F%E6%88%90%E5%91%98%E7%9A%84%E5%9C%B0%E5%9D%80" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>引用结构体变量或结构体变量成员的地址</h3>
<h4><a id="%E4%BE%8B%E5%A6%82%EF%BC%9A" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>例如：</h4>
<pre class="line-numbers"><code class="language-c">scanf(&quot;%o&quot;, &amp;student1.num);
//输入student1.num的值
printf(&quot;%o&quot;, &amp;dtudent1);
//输出student1的首地址
</code></pre>
<p><strong>注意：</strong> 不能通过以下语句整体输入结构体变量</p>
<pre class="line-numbers"><code class="language-c">scanf(&quot;%d, %s, %c ,%f, %s&quot;, &amp;student1);
</code></pre>
<h4><a id="%E4%BE%8B%E9%A2%98" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>例题</h4>
<p>输入两个学生的学号、姓名和成绩，输出成绩较高的学生的学号、姓名和成绩</p>
<h5><a id="%E5%88%86%E6%9E%90" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>分析</h5>
<ul>
<li>定义两个结构相同的结构体变量student1和student2</li>
<li>分别输入两个学生的学号、姓名和成绩</li>
<li>比较两个学生的成绩，就输出成绩较高的学生的全部信息，如果成绩相等，输出2个学生的全部信息</li>
</ul>
<pre class="line-numbers"><code class="language-c">#include &lt;stdio.h&gt;
struct stu
{
    long num;   //学号为长整型
    char *name; //姓名为字符串指针
    int score;  //成绩为整型
};

void print(struct stu p) //对输出学生信息的printf()语句进行封装
{
    printf(&quot;Num = %ld, Name = %s, Score = %d\n&quot;, p.num, p.name, p.score);
}

int main()
{
    struct stu s1 = {10001, &quot;卡夫&quot;, 80};
    struct stu s2 = {10002, &quot;铃&quot;, 80};

    if (s1.score &gt; s2.score)
        print(s1);
    else if (s1.score &lt; s2.score)
        print(s2);
    else
    {
        print(s1);
        print(s2);
    }

    return 0;
}
</code></pre>
<h2><a id="%E7%BB%93%E6%9E%84%E4%BD%93%E6%95%B0%E7%BB%84" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>结构体数组</h2>
<p>结构数组的每个数组元素都是一个结构体类型的数据，它们都分别包含各个成员项</p>
<h3><a id="%E5%AE%9A%E4%B9%89%E5%BD%A2%E5%BC%8F" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>定义形式</h3>
<h4><a id="%E5%AE%9A%E4%B9%89%E7%BB%93%E6%9E%84%E4%BD%93%E6%95%B0%E7%BB%84%E7%9A%84%E4%B8%80%E8%88%AC%E5%BD%A2%E5%BC%8F" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>定义结构体数组的一般形式</h4>
<h5><a id="1%E3%80%81%E5%90%8C%E6%97%B6%E8%BF%9B%E8%A1%8C%E5%A3%B0%E6%98%8E%E5%92%8C%E5%AE%9A%E4%B9%89" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>1、同时进行声明和定义</h5>
<pre class="line-numbers"><code class="language-c">struct 结构体名
{
    成员表列
} 数组名[数组长度];
</code></pre>
<h5><a id="2%E3%80%81%E5%85%88%E5%A3%B0%E6%98%8E%E5%86%8D%E5%AE%9A%E4%B9%89" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>2、先声明再定义</h5>
<pre class="line-numbers"><code class="language-c">struct 结构体名
{
    成员表列
};

struct 结构体名 数组名[数组长度];
</code></pre>
<h4><a id="%E5%88%9D%E5%A7%8B%E5%8C%96%E7%BB%93%E6%9E%84%E4%BD%93%E6%95%B0%E7%BB%84" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>初始化结构体数组</h4>
<p>结构体数组初始化的形式是在定义数组后加上<code>= {初值表列}</code></p>
<pre class="line-numbers"><code class="language-c">struct 结构体名 数组名[数组长度] = {初值表列};
</code></pre>
<p>或</p>
<pre class="line-numbers"><code class="language-c">struct 结构体名 数组名[数组长度] = {元素1初值},{元素2初值}···};
</code></pre>
<h4><a id="%E4%B8%BE%E4%BE%8B" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>举例</h4>
<p>有3个候选人，输入候选人的名字可以对该候选人投票，投票结束后输出每个候选人的名字和得票数</p>
<pre class="line-numbers"><code class="language-c">#include &lt;stdio.h&gt;
#include &lt;string.h&gt;

struct person //声明结构数组`struct person`
{
    char name[20]; //候选人名字
    int count;     //候选人得票数
} leader[3] = {&quot;Zhou&quot;, 0, &quot;Zhang&quot;, 0, &quot;He&quot;, 0};

int main()
{
    int i;
    char leader_name[20]; //定义字符数组
    do
    {
        scanf(&quot;%s&quot;, leader_name); //输入候选人名字
        for (i = 0; i &lt; 3; i++)
        {
            if (strcmp(leader_name, leader[i].name) == 0) //匹配输入的名字与候选人名字
                leader[i].count++;                        //给匹配成功的候选人+1票数
            i++;
        }
    } while (strcmp(leader_name, &quot;end&quot;) != 0); //当输入end时结束循环

    //输出所有候选人的票数
    for (i = 0; i &lt; 3; i++)
    {
        printf(&quot;%s %d\n&quot;, leader[i].name, leader[i].count);
    }
    return 0;
}
</code></pre>
<h2><a id="%E7%BB%93%E6%9E%84%E4%BD%93%E6%8C%87%E9%92%88" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>结构体指针</h2>
<ul>
<li>
<p>结构体指针是指向结构体数据的指针，一个结构体变量的起始地址就是这个结构体变量的指针</p>
</li>
<li>
<p>指针变量可以指向结构体变量，也可以指向结构体数组中的元素，但指针变量的<code>基类型</code>必须与<code>结构体变量</code>的类型相同</p>
</li>
<li>
<p>结构体变量的指针不能指向结构体的某一个成员</p>
</li>
</ul>
<h3><a id="%E4%BE%8B%E5%A6%82" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>例如</h3>
<pre class="line-numbers"><code class="language-c">struct student *pt;
</code></pre>
<p>pt可以指向struct student类型的数据</p>
<h3><a id="%E4%BE%8B%E9%A2%981" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>例题1</h3>
<p>通过指向结构体变量的指针变量输出结构体变量中的成员的信息</p>
<h4><a id="%E6%9C%AC%E9%A2%98%E9%9C%80%E8%A6%81%E8%A7%A3%E5%86%B3%E4%B8%A4%E4%B8%AA%E9%97%AE%E9%A2%98" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>本题需要解决两个问题</h4>
<ul>
<li>怎样对结构体变量成员的赋值</li>
<li>怎样通过指向结构体变量的指针访问结构体变量中的成员</li>
</ul>
<pre class="line-numbers"><code class="language-c">#include &lt;stdio.h&gt;

int main()
{
    struct stu
    {
        int num;
    };
    struct stu s;  //定义一个struct stu类型的变量s
    struct stu *p; //定义一个struct stu类型的指针变量*p

    p = &amp;s; // p指向结构体变量s
    (*p).num = 1;
    printf(&quot;%d&quot;, (*p).num);
    return 0;
}
</code></pre>
<p><strong>注意：</strong> 如果p指向一个结构体变量，C语言允许使用p-&gt;num来替代(*p).num，它表示p所指向的结构体变量中的num成员，<code>-&gt;</code>称为指向运算符，以下3种形式等价：</p>
<pre class="line-numbers"><code class="language-c">结构体变量.成员名
( *p ).成员名
p -&gt; 成员名
</code></pre>
<h3><a id="%E4%BE%8B%E9%A2%982" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>例题2</h3>
<p>有三个学生的信息，存放在结构体数组中，要求输出全部学生信息</p>
<h4><a id="%E5%88%86%E6%9E%90" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>分析</h4>
<ul>
<li>声明结构体类型<code>struct student</code>，并定义结构体数组，同时使之初始化</li>
<li>定义一个指向<code>struct student</code>类型数据的指针变量<code>p</code></li>
<li>使<code>p</code>指向结构体数组的首元素，输出它指向的元素中的有关信息</li>
<li>使<code>p</code>指向结构体数组的下一个元素，输出它指向的元素中的有关信息</li>
<li>再使<code>p</code>指向结构体数组的下一个元素，输出它指向的元素中的有关信息</li>
</ul>
<pre class="line-numbers"><code class="language-c">#include &lt;stdio.h&gt;

struct student
{
    char name[20];
    int num;
    int score;
};
int main()
{
    struct student stu[3] = {
        {&quot;kafuu&quot;, 10001, 100},
        {&quot;Ling&quot;, 10002, 80},
        {&quot;jjmy8888&quot;, 10003, 60}};

    struct student *p; //定义一个struct stu类型的指针变量*p

    p = stu; // p指向结构体数组stu的首地址
    while (p &lt; stu + 3)
    {
        printf(&quot;%s %d %d\n&quot;, p-&gt;name, p-&gt;num, p-&gt;score);
        p++;
    }
    return 0;
}
</code></pre>
<h4><a id="%E8%AF%B4%E6%98%8E" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>说明</h4>
<ul>
<li>
<p>如果<code>p</code>的初值为<code>stu</code>，即指向<code>stu</code>的第一个元素，<code>p++</code>后，<code>p</code>就指向下一个元素</p>
</li>
<li>
<p>程序已经定义了<code>p</code>是一个指向<code>struct student</code>类型数据的指针变量，它用来指向<code>struct student</code>类型的数据，不应该用来指向<code>stu</code>数组元素中的某一成员</p>
</li>
</ul>
<h2><a id="%E7%94%A8%E6%8C%87%E9%92%88%E5%AE%9E%E7%8E%B0%E5%8A%A8%E6%80%81%E5%86%85%E5%AD%98%E5%88%86%E9%85%8D" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>用指针实现动态内存分配</h2>
<h3><a id="%E5%BC%95%E7%94%A8%E5%A4%B4%E6%96%87%E4%BB%B6" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>引用头文件</h3>
<pre class="line-numbers"><code class="language-c">#include &lt;stdlib.h&gt;
</code></pre>
<h4><a id="malloc%E5%87%BD%E6%95%B0" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>malloc()函数</h4>
<p>该函数可以灵活的完成空间的分配</p>
<pre class="line-numbers"><code class="language-c">malloc(m);
</code></pre>
<ul>
<li>分配m字节长度的地址空间，并返回这段空间的首地址</li>
</ul>
<p><strong>注意</strong><br />
该函数的返回值是<code>void *</code>类型，需要通过强制类型转换将分配的大空间拆分成小空间</p>
<pre class="line-numbers"><code class="language-c">(数据类型 *)malloc(m)
</code></pre>
<h4><a id="free%E5%87%BD%E6%95%B0" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>free()函数</h4>
<p>释放指针<code>p</code>所指向的变量的存储空间，即彻底删除一个变量</p>
<h5><a id="%E4%BE%8B%E5%A6%82" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>例如</h5>
<p>分配10个整型变量存储空间，并把首地址存放在指针变量<code>p</code>中</p>
<pre class="line-numbers"><code class="language-c">int *p;
p = (int *)malloc(10*sizeof(int)); 
//分配存储空间，并将malloc()函数的返回值进行强制类型转换用于划分空间

free(p); //释放存储空间
</code></pre>
<p><strong>!!以下操作存在危险!!</strong></p>
<pre class="line-numbers"><code class="language-c">#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

int main()
{
    int *p = (int *)malloc(10 * sizeof(int));
    *p = 10;

    //可能造成*p内存储的空间首地址丢失的操作
    p++;
    *p = 20;

    return;
}
</code></pre>
<p>应当使用以下方法</p>
<pre class="line-numbers"><code class="language-c">#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

int main()
{
    int *p = (int *)malloc(10 * sizeof(int));
    *p = 10;

    *(p + 1) = 20; //应该用这种操作进行赋值

    return;
}

</code></pre>
<h2><a id="%E7%94%A8%E6%8C%87%E9%92%88%E5%A4%84%E7%90%86%E9%93%BE%E8%A1%A8" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>用指针处理链表</h2>
<p>线性链表就是动态地进行存储分配的一种数据结构</p>
<p><img src="media/16433059075657/16441320554486.jpg" alt="" /></p>
<h3><a id="%E9%93%BE%E8%A1%A8%E7%9A%84%E7%BB%84%E6%88%90" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>链表的组成</h3>
<h4><a id="%E5%A4%B4%E6%8C%87%E9%92%88" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>头指针</h4>
<p>  存放一个地址，该地址指向一个元素</p>
<h4><a id="%E7%BB%93%E7%82%B9" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>结点</h4>
<p>  用户需要的实际数据和链接结点的指针</p>
<h3><a id="%E7%94%A8%E7%BB%93%E6%9E%84%E4%BD%93%E5%BB%BA%E7%AB%8B%E9%93%BE%E8%A1%A8" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>用结构体建立链表</h3>
<pre class="line-numbers"><code class="language-c">struct node
{
    int data;
    struct node *next; //结构体指针，指向下一个结构体的地址
}
</code></pre>
<p>其中成员<code>data</code>用来存放结点中的有用数据，<code>next</code>是指针类型的成员，它指向<code>struct node</code>类型数据</p>
<h4><a id="%E7%A4%BA%E4%BE%8B" class="anchor" aria-hidden="true"><span class="octicon octicon-link"></span></a>示例</h4>
<pre class="line-numbers"><code class="language-c">#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

struct node
{
    char data;
    struct node *next;
};

int main()
{
    struct node *head, *p, *q;
    int i;
    head = (struct node *)malloc(sizeof(struct node)); //创建第一个结点，head为头指针，指向头一个结点
    head-&gt;data = 'A';
    head-&gt;next = NULL; // q-&gt;next为空
    p = head;

    for (i = 1; i &lt; 5; i++) //建立链表
    {
        q = (struct node *)malloc(sizeof(struct node)); //创建一个新结点，q指向新结点
        q-&gt;data = 'A' + i;
        q-&gt;next = NULL; // q-&gt;next为空
        p-&gt;next = q;    // p-&gt;next为当前结点的指针部分，指向新结点，建立了当前结点到下一个结点的指向关系
        p = q;          // p指向下一个结点
    }
    p = head;
    while (p != NULL) //输出链表内容
    {
        printf(&quot;%c--&gt;&quot;, p-&gt;data);
        p = p-&gt;next;
    }

    printf(&quot;NULL\n&quot;);

    return 0;
}
</code></pre>

				</article>
				<div class="comments-wrap">
					<div class="share-comments">
						

						

						
					</div>
				</div><!-- end comments wrap -->
			</div>
		</div><!-- end columns -->
	</div><!-- end container -->
</section>  














<script src="asset/prism.js"></script>









</body>

</html>